home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995…tember: Reference Library / Dev.CD Sep 95 RL / Dev.CD Sep 95 RL.toast / mac / Technical Documentation / develop / develop Issue 22 code / PCI Driver Sample / NCR_DriverProject / Src / NCR53C825.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-05  |  21.3 KB  |  470 lines  |  [TEXT/MPCC]

  1. /*                                        NCR53C825.h                                    */
  2. /*
  3.  * NCR53C825.h
  4.  * Copyright © 1994 Apple Computer Inc. All rights reserved.
  5.  */
  6. /*    .___________________________________________________________________________________.
  7.       | This is a private interface file for the sample driver. It contains configuration    |
  8.     | parameters, driver-specific global definitions, and function prototypes.            |
  9.     | This interface file contains all hardware-specific data and won't make much sense    |
  10.     | without the NCR documemtation.                                                    |
  11.     .___________________________________________________________________________________.
  12.  */
  13.  
  14. #ifndef __NCR53C825__
  15. #define __NCR53C825__
  16. /*
  17.  * TEST_DRIVER is set TRUE by the test function. When non-zero it blocks definition
  18.  * of the driver's chip-access functions.
  19.  */
  20. #ifndef TEST_DRIVER
  21. #define TEST_DRIVER                0
  22. #endif
  23.  
  24. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  25.  * The PerRequestRecord is used for each NCR Script operation. If we ever support
  26.  * multiple independent transactions -- to support disconnect/reselect for example,
  27.  * this structure must be replicated on a per-transaction basis. Currently, it
  28.  * has two components:  the table used by the NCR Script processor and the mapping
  29.  * vector that the Macintosh operating system uses to map memory between logical
  30.  * and physical addresses. In order to simplify the sample driver, we do not
  31.  * support scatter-gather I/O - this is primarily a function of not wanting to
  32.  * write an elaborate script. Thus, our use of a MappingTable is mostly overkill.
  33.  */
  34.  
  35. /*
  36.  * The Table is used for NCR "table-indirect" operations. Note: the table must
  37.  * be allocated on a 32-bit address boundary. Note that the address is a
  38.  * longword-swapped PhysicalAddress as the NCR chip wants it in little-endian format.
  39.  */
  40. struct Table {
  41.     ByteCount            byteCount;                /* Data transfer count                */
  42.     UInt32                address;                /* Data transfer address            */
  43. };
  44. typedef struct Table    Table, *TablePtr;
  45.  
  46. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  47.  * Define phase bits - DATO..MSGI are normal SCSI phases. The additional values are
  48.  * aretificial. The script writes the current phase (real or artificial) into the
  49.  * SCRATCHA register, where it can be retrieved by the interrupt handler. This is
  50.  * used to recover from variable-length reads where the user buffer length is greater
  51.  * than the target intents to transmit.
  52.  */
  53. enum {
  54.     DATO    =    0,                /* Data output (host -> device)                        */
  55.     DATI    =    1,                /* Data input  (device -> host)                        */
  56.     CMD        =    2,                /* Command                                            */
  57.     STS        =    3,                /* Status                                            */
  58.     RESO    =    4,                /* Reserved out    -- not used                            */
  59.     RESI    =    5,                /* Reserved in -- not used                            */
  60.     MSGO    =    6,                /* Message output                                    */
  61.     MSGI    =    7,                /* Message input                                    */
  62.     ARB_SEL    =    8                /* Arbitration "phase"                                */
  63. };
  64. #define kScsiMsgAbort    0x06    /* Message byte to abort (possibly) a target        */
  65.  
  66. /*
  67.  * Offsets into the SCSI Script. These are added to GLOBAL.scriptPhysicalMapping[0]
  68.  * to get the value to store into the NCR Chip's script address. The memory test
  69.  * and interrupt tests use a script that is constructed on-the-fly.
  70.  */
  71. typedef enum {
  72.     kBusResetScript            = 0x08,    /* Execute the bus reset script                    */
  73.     kBusResetScriptRestart    = 0x10,    /* Restart the bus reset script after delay        */
  74.     kSCSICommandScript        = 0x18,    /* Execute the normal SCSI command script        */
  75.     kSCSIRundownScript        = 0x20,    /* Restart at I/O rundown (failure) script        */
  76.     kSCSIRestartScript        = 0x28,    /* Restart at main phase loop                    */
  77.     kSCSITestISRScript        = 0x01,    /* Artificial value to indicate ISR test        */
  78.     kSCSITestMemoryScript    = 0x02    /* Artificial value to indicate memory test        */
  79. } ScriptSelector;
  80.  
  81. /*
  82.  * Values for the NCR INT operation. Before jumping to the failure sequence, the
  83.  * script interrupts to log the failure for debugging.
  84.  */
  85. enum {
  86.     kIntNeedAnotherPreparation    = 10000, /* Expected: need to PrepareMemoryForIO    */
  87.     kIntFailStrangePhase,                /* 10001 Bug: unknown phase at phase loop    */
  88.     kIntDataPhaseExpected,                /* 10002 At 'Data', but not in data phase    */
  89.     kIntPreparationFailed,                /* 10003 CTEST == 0 after prep restart        */
  90.     kIntDataOutNoData,                    /* 10004 CTEST not == 2 at DATO phase        */
  91.     kIntDataInNoData,                    /* 10005 CTEST not == 1 at DATI phase        */
  92.     kIntNotMsgInAfterStatus,            /* 10006 STS phase must be followed by MSGI    */
  93.     kIntLastStatusWithoutComma
  94. };
  95.     
  96. /*
  97.  * This is the data that the Script processor accesses (by DMA initiated from the
  98.  * PCI bus). The arrows indicate the direction of data flow vis-a-vis the script.
  99.  * Note: the deviceID and dataTables must be on longword boundaries.
  100.  */
  101. struct ScriptData {
  102.     /*
  103.      * deviceIDTable must be the first location in the script data area.
  104.      */
  105.     Table            deviceIDTable;                /* -> Target id    (longword aligned)    */
  106.     Table            idMsgTable;                    /* -> ARB/ATN Msg Out byte            */
  107.     Table            commandTable;                /* -> SCSI command and length        */
  108.     Table            dataTable;                    /* -> User data                        */
  109.     Table            statusTable;                /* -> Status byte                    */
  110.     Table            completeTable;                /* -> Command Complete Msg In byte    */
  111.     Table            bitBucketInTable;            /* -> Bit bucket for input phases    */
  112.     Table            bitBucketOutTable;            /* -> Bit bucket for output phases    */
  113.     Table            ignoredMsgTable;            /* -> To read uninteresting msg's    */
  114.     unsigned char    scsiCommand[12];            /* -> SCSI Command copied here        */
  115.     unsigned char    idMsgByte;                    /* -> Initialization message byte    */
  116.     unsigned char    statusByte;                    /* <- Status phase result            */
  117.     unsigned char    commandCompleteByte;        /* <- Command complete result        */
  118.     unsigned char    bitBucketInByte;            /* <- DATI bit-bucket                */
  119.     unsigned char    bitBucketOutByte;            /* -> DATO bit-bucket                */
  120.     unsigned char    ignoredMsgInByte;            /* <- MSGI bit-bucket (ignored msg)    */
  121.     OSErr            ncrStatus;                    /* Non-zero on failure                */
  122. };
  123. typedef struct ScriptData ScriptData, *ScriptDataPtr;
  124.  
  125. /*
  126.  * When the NCR chip interrupts, the interrupt service routine retrieves volatile
  127.  * information from the NCR chip and stores it in the request block. In a real
  128.  * driver, these might be local variables in the interrupt service routine. They
  129.  * are here so they can be dumped for post-mortem debugging. The hex values are
  130.  * the register addresses in the NCR chip.
  131.  */
  132. struct NCRRegisterShadow {
  133.     unsigned long        residualTransferCount;    /* Bytes remainomg at phase error    */
  134.     unsigned long        dbc;                    /* 0x24 data byte count value        */
  135.     unsigned long        dsp;                    /* 0x2C Script data pointer            */
  136.     unsigned long        dsps;                    /* 0x30 SCSI interrupt condition    */
  137.     unsigned char        scntl1;                    /* 0x01 SCSI Control One            */
  138.     unsigned char        istat;                    /* 0x14 Interrupt status            */
  139.     unsigned char        dstat;                    /* 0x0C DMA interrupt status        */
  140.     unsigned char        sist0;                    /* 0x42 SCSI interrupt status zero    */
  141.     unsigned char        sist1;                    /* 0x43 SCSI interrupt status one    */
  142.     unsigned char        socl;                    /* 0x09 SCSI output control lines    */
  143.     unsigned char        sbcl;                    /* 0x0B SCSI bus control lines        */
  144.     unsigned char        sstat0;                    /* 0x0D SCSI status zero            */
  145.     unsigned char        sstat1;                    /* 0x0E SCSI status one                */
  146.     unsigned char        sstat2;                    /* 0x0F SCSI status two                */
  147.     unsigned char        dfifo;                    /* 0x20 dma fifo byte counter        */
  148.     /*
  149.      * ctest3 and stest3 are only read to clear a dma fifo non-empty error condition.
  150.      */
  151.     unsigned char        ctest3;                    /* 0x1B Chip Test three                */
  152.     unsigned char        stest3;                    /* 0x4F SCSI Test three                */
  153.     short                scriptPCOffset;            /* dsp - gNCRScript                    */
  154. };
  155. typedef struct NCRRegisterShadow NCRRegisterShadow;
  156.  
  157. /*
  158.  * This defines the data that is retained for individual transactions. A pointer to
  159.  * this structure is passed to the interrupt service routine.
  160.  *
  161.  * Note: PerRequestData must be allocated on a 32-bit address boundary - the NCR chip
  162.  * requires table indirect records to be longword aligned. PerRequestData is defined
  163.  * in the NCR53C850.h header file. If we extend the driver to permit multiple
  164.  * simultaneous transfers, we'll need a PerRequestData structure for each simultaneous
  165.  * execution thread. As these must be allocated from "task" context, we may allocate
  166.  * a "pool" of PerRequestData records when the driver is opened. For now, we allocate a
  167.  * single PerRequestData record.
  168.  */
  169. #if STRUCTALIGNMENTSUPPORTED
  170. #pragma options align=power
  171. #endif
  172. struct PerRequestData {
  173.     ScriptData                scriptData;            /* Data shared with the NCR chip    */      
  174.     NCRRegisterShadow        shadow;                /* The NCR registers at interrupt    */
  175.     /*
  176.      * This data is changed with each PBRead/PBWrite/PBControl I/O request.
  177.      */
  178.     TimerID                    timerID;            /* Interrupt Timer ID                */
  179.     AddressSpaceID            addressSpaceID;        /* From the DoDriverIO call            */
  180.     IOCommandID                ioCommandID;        /* From the DoDriverIO call            */
  181.     ParmBlkPtr                pb;                    /* From the DoDriverIO call            */
  182.     ScriptSelector            scriptSelector;        /* SCSI or Bus Reset script            */
  183.     Duration                watchdogTimeout;    /* -> Msec timeout, zero = none        */
  184.     /*
  185.      * This data is initialized when the PerRequestData record is created.
  186.      *    perRequestIOTable        Preparation table for the perRequestRecord
  187.      *    scsiIOTable                Preparation table for the caller's SCSI command.
  188.      *    scsiMapSize                Number of elements in the scsiPhysicalMapping vector.
  189.      */
  190.     ItemCount                scsiMapSize;
  191.     IOPreparationTable        perRequestIOTable;    /* Preparation for this record        */
  192.     /*
  193.      * This augments the perRequestIOTable to support partial preparation.
  194.      */
  195.     IOPreparationTable        scsiIOTable;        /* PrepareMemoryForIO information    */
  196.     SoftwareInterruptID        nextDMAInterruptID;    /* Used for subsequent preparations    */
  197.     LogicalAddress            userBufferStart;    /* User area yet to prepare            */
  198.     LogicalAddress            userBufferEnd;        /* Used to check I/O overrun        */
  199.     ByteCount                amountToTransfer;    /* Amount remaining to prepare        */
  200.     ByteCount                dmaFirstPrepared;     /* This partial I/O start offset    */
  201.     ByteCount                dmaLengthPrepared;    /* This partial I/O transfer count    */
  202.     ItemCount                physicalMapIndex;    /* -> physicalMapping[] for DMA        */
  203.     /*
  204.      * Script physical addresses (from their respective IOPreparation tables).
  205.      */
  206.     UInt32                    scriptBaseAddress;    /* Script start address                */
  207.     UInt32                    scriptPtr;            /* PhysicalAddress of the script    */
  208.     UInt32                    scriptDataPtr;        /* PhysicalAddress of script data    */
  209.     /*
  210.      * physicalMapTables holds the physical mapping tables for the user I/O requests
  211.      * and for the PerRequestData record itself.
  212.      */
  213.     ItemCount                scsiMapEntries;        /* Elements for user SCSI requests    */
  214.     PhysicalMappingTablePtr    physicalMapTables;    /* PhysicalMapping for this request    */
  215.     /*
  216.      * This area is used to create a dynamic script for memory and interrupt scripts.
  217.      * The stateTag is copied from the NCRCSCIParam block in the IOParam block.
  218.      */
  219.     UInt32                    memoryMoveScript[5];
  220. };
  221. #if STRUCTALIGNMENTSUPPORTED
  222. #pragma options align=reset
  223. #endif
  224. typedef struct PerRequestData PerRequestData, *PerRequestDataPtr;
  225.  
  226. /*
  227.  * PCI configuration definitions - I got these by installing the board and dumping
  228.  * the property list. They differ slightly from the printed documentation. Only the
  229.  * device name and kPCIRevisionID are used.
  230.  */
  231. #define kPCIVendorID            0x1000        /* 00 15- 0    Registered vendor ID        */
  232. #define kPCIClassCode            0x00010000    /* 08 31- 8    Registered class code        */
  233. #define kPCIRevisionID            0x02        /* 08  7- 0    Registered revision ID        */
  234. #define kPCIRegisterSize        0x100        /* Size of the I/O and/or Mem area        */
  235. /*
  236.  * These are offsets within the Configuration Register area that Open Firmware uses
  237.  * to determine the register mapping. The driver can use the I/O and/or memory base
  238.  * registers. Expansion rom is not used, but could be used by a utility that stores
  239.  * a driver into the NCR flash rom.
  240.  */
  241. #define kPCIIOBaseRegister            0x10    /* I/O base address in Config Reg's        */
  242. #define kPCIMemoryBaseRegister        0x14    /* Memory base address in Config Reg's    */
  243. #define kPCIExpansionROMRegister    0x30    /* Expansion rom base in Config Reg's    */
  244. /*
  245.  * These definitions specify the hardware we support. kPCIDeviceID is in the
  246.  * configuration register. kPCIChipRevision is read from an on-chip register.
  247.  * The only difference between the two versions is the device name string, device
  248.  * id, and the chip revision. To do: build the driver core as a shared library,
  249.  * build two stub drivers with independent DriverDescription structures, and
  250.  * update the chip revision test.
  251.  */
  252. #if 0    /* NCR 53C825 */
  253. #define kPCIDeviceNamePString    "\ppci1000,3"    /* Name string - StringPtr            */
  254. #define kPCIDeviceNameCString    "pci1000,3"        /* Name string - C string            */
  255. #define    kPCIDeviceID            0x0003            /* 00 31-16 Registered device ID    */
  256. #define kPCIChipRevision        (bit5)            /* CTEST3 value                        */
  257. #elif 1    /* NCR 53C815 */
  258. #define kPCIDeviceNamePString    "\ppci1000,4"    /* Name string - StringPtr            */
  259. #define kPCIDeviceNameCString    "pci1000,4"        /* Name string - C string            */
  260. #define kPCIDeviceID            0x0004            /* 00 31-16 Registered device ID    */
  261. #define kPCIChipRevision        (bit5 | bit4)     /* CTEST3 value                        */
  262. #elif 0 /* NCR 53C825 with AAPL name */
  263. #define kPCIDeviceNamePString    "\pAAPL,NCR8250S"    /* Name string - StringPtr        */
  264. #define kPCIDeviceNameCString    "AAPL,NCR8250S"        /* Name string - C string        */
  265. #define    kPCIDeviceID            0x0003            /* 00 31-16 Registered device ID    */
  266. #define kPCIChipRevision        (bit5)            /* CTEST3 value                        */
  267. #else
  268. /* Unknown */
  269. #endif
  270. #if 0
  271. /*
  272.  * As part of our "manufacturing process" we have changed the name by updating
  273.  * the on-board firmware.
  274.  */
  275. #undef kPCIDeviceNamePString
  276. #undef kPCIDeviceNameCString
  277. #define kPCIDeviceNamePString    "\pAAPL,NCR8250S"    /* Name string - StringPtr        */
  278. #define kPCIDeviceNameCString    "AAPL,NCR8250S"        /* Name string - C string        */
  279. #endif
  280.  
  281. #define kBusResetDuration        (50)        /* Bus Reset lasts 50 microseconds        */
  282. #define kMaxSCSIInitiatorID        7            /* Change this for wide support            */
  283. #define kSCSIInitiatorID        7            /* Our default SCSI bus ID                */
  284.  
  285. /*
  286.  * The first time that a script is executed, labels will be resolved to their
  287.  * pc-relative values. To make this work, the first and last instructions of each
  288.  * each script must be marked with Label instructions. The script-runner uses
  289.  * kScriptStartLabel to identify un-resolved scripts.
  290.  */
  291. #define kScriptStartLabel    '++++'
  292. /*
  293.  * This is a little-endian "INT" instruction for the memory and interrupt tests.
  294.  */
  295. #define kIntOpcode        0x00000898
  296.  
  297. #ifndef REZ
  298.  
  299. #define bit0            0x00000001
  300. #define bit1            0x00000002
  301. #define bit2            0x00000004
  302. #define bit3            0x00000008
  303. #define bit4            0x00000010
  304. #define bit5            0x00000020
  305. #define bit6            0x00000040
  306. #define bit7            0x00000080
  307. #define bit8            0x00000100
  308. #define bit9            0x00000200
  309. #define bit10            0x00000400
  310. #define bit11            0x00000800
  311. #define bit12            0x00001000
  312. #define bit13            0x00002000
  313. #define bit14            0x00004000
  314. #define bit15            0x00008000
  315. #define bit16            0x00010000
  316. #define bit17            0x00020000
  317. #define bit18            0x00040000
  318. #define bit19            0x00080000
  319. #define bit20            0x00100000
  320. #define bit21            0x00200000
  321. #define bit22            0x00400000
  322. #define bit23            0x00800000
  323. #define bit24            0x01000000
  324. #define bit25            0x02000000
  325. #define bit26            0x04000000
  326. #define bit27            0x08000000
  327. #define bit28            0x10000000
  328. #define bit29            0x20000000
  329. #define bit30            0x40000000
  330. #define bit31            0x80000000
  331.  
  332.  
  333. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  334.  * Configuration Registers
  335.  *
  336.  * This table gives offsets to registers in the NCR53C825 chip. The configuration
  337.  * registers (0..128) are only available during configuration cycles. All values
  338.  * are hex byte offsets. Note:
  339.  *    cl            Configuration Longword
  340.  *    cw            Configuration Short (16-bit) word
  341.  *    cb            ConfigurationByte
  342.  */
  343. enum {
  344.     kConfigStart        = 0x00,
  345.     cwVendorID            = 0x00,            /* 0x1000                                    */
  346.     cwDeviceID            = 0x02,            /* 0x0003                                    */
  347.     cwCommand            = 0x04,
  348.     cwStatus            = 0x06,
  349.     clClassCodeAndRevID    = 0x08,
  350.     clHeaderAndLatency    = 0x0C,
  351.     clBaseAddressZero    = 0x10,            /* I/O Base address                            */
  352.     clBaseAddressOne    = 0x14,            /* Memory Base address                        */
  353.     clExpansionRomAddr    = 0x30,
  354.     clLatGntIntPinLine    = 0x3C,            /* Max_Lat, Max_Gnt, Int. Pin, Int. Line    */
  355.     kConfigEnd            = 0x40
  356. };
  357.  
  358. /*
  359.  * 0x04 cwCommand                    Command Register (read/write)
  360.  */
  361. enum {
  362.     cwCommandSERREnable            = bit8,
  363.     cwCommandEnableParityError    = bit6,
  364.     cwCommandEnableBusMaster    = bit2,        /* Set this on initialization            */
  365.     cwCommandEnableMemorySpace    = bit1,        /* Respond at Base Address One if set    */
  366.     cwCommandEnableIOSpace        = bit0        /* Respond at Base Address Zero if set    */
  367. };
  368. /*
  369.  * 0x06 cwStatus                    Status Register (read/write)
  370.  */
  371. enum {
  372.     cwStatusDetectedParityError    = bit15,    /* Detected from slave                    */
  373.     cwStatusSignaledSystemError = bit14,    /* Device asserts SERR/ signal            */
  374.     cwStatusMasterAbort             = bit13,    /* Master sets when transaction aborts    */
  375.     cwStatusReceivedTargetAbort    = bit12,    /* Master sets when target-abort        */
  376.     cwStatusDEVSELTimingMask    = (bit10 | bit9),    /* DEVSEL timing encoding R/O    */
  377.      cwStatusDEVSELFastTiming    = 0,
  378.      cwStatusDEVSELMediumTiming    = bit9,
  379.      cwStatusDEVSELSlowTiming    = bit10,
  380.     cwStatusDataParityReported    = bit8
  381. };
  382.         
  383.  
  384. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  385.  * Operating Registers
  386.  *
  387.  * These registers control the 53C825 operation. All values are hex byte offsets.
  388.  * You'll need to consult the NCR documentation for register sizes and uses.
  389.  */
  390. enum {
  391.     kRegisterBase    = 0x80,                    /* Offset from config memory base        */
  392.     SCNTL0            = kRegisterBase + 0x00,    /* b RW SCSI Control 0                    */
  393.     SCNTL1            = kRegisterBase + 0x01,    /* b RW SCSI Control 1                    */
  394.     SCNTL2            = kRegisterBase + 0x02,    /* b RW SCSI Control 2                    */
  395.     SCNTL3            = kRegisterBase + 0x03,    /* b RW SCSI Control 3                    */
  396.     SCID            = kRegisterBase + 0x04,    /* b RW SCSI Chip ID                    */
  397.     SCXFER            = kRegisterBase + 0x05,    /* b RW SCSI Transfer                    */
  398.     SDID            = kRegisterBase + 0x06,    /* b RW SCSI Destination ID                */
  399.     GPREG            = kRegisterBase + 0x07,    /* b RW General Purpose Bits            */
  400.     SFBR            = kRegisterBase + 0x08,    /* b RW SCSI First Byte Received        */
  401.     SOCL            = kRegisterBase + 0x09,    /* b RW SCSI Output Control Latch        */
  402.     SSID            = kRegisterBase + 0x0A,    /* b RO SCSI Selector ID                */
  403.     SBCL            = kRegisterBase + 0x0B,    /* b RW SCSI Bus Control Lines            */
  404.     DSTAT            = kRegisterBase + 0x0C,    /* b RO DMA Status                        */
  405.     SSTAT0            = kRegisterBase + 0x0D,    /* b RO SCSI Status 0                    */
  406.     SSTAT1            = kRegisterBase + 0x0E,    /* b RO SCSI Status 1                    */
  407.     SSTAT2            = kRegisterBase + 0x0F,    /* b RO SCSI Status 2                    */
  408.     DSA                = kRegisterBase + 0x10,    /* l RW Data Structure Address            */
  409.     ISTAT            = kRegisterBase + 0x14,    /* b RW Interrupt Status                */
  410.     CTEST0            = kRegisterBase + 0x18,    /* b RW Chip Test 0                        */
  411.     CTEST1            = kRegisterBase + 0x19,    /* b RW Chip Test 1                        */
  412.     CTEST2            = kRegisterBase + 0x1A,    /* b RO Chip Test 2                        */
  413.     CTEST3            = kRegisterBase + 0x1B,    /* b RO Chip Test 3                        */
  414.     TEMP            = kRegisterBase + 0x1C,    /* l RW Temporary Stack (Return Stack)    */
  415.     DFIFO            = kRegisterBase + 0x20,    /* b RW DMA Fifo                        */
  416.     CTEST4            = kRegisterBase + 0x21,    /* b RW Chip Test 4                        */
  417.     CTEST5            = kRegisterBase + 0x22,    /* b RW Chip Test 5                        */
  418.     CTEST6            = kRegisterBase + 0x23,    /* b RW Chip Test 6                        */
  419.     DBC                = kRegisterBase + 0x24,    /* l RW DMA Byte Counter (bits 23-0)    */
  420.     DCMD            = kRegisterBase + 0x27,    /* b RW DMA Command                        */
  421.     DNAD            = kRegisterBase + 0x28,    /* l RW DMA Next address for data        */
  422.     DSP                = kRegisterBase + 0x2C,    /* l RW DMA Scripts pointer (Script PC)    */
  423.     DSPS            = kRegisterBase + 0x30,    /* l RW DMA Scripts Pointer Save        */
  424.     SCRATCHA        = kRegisterBase + 0x34,    /* l RW General purpose scratch A        */
  425.     DMODE            = kRegisterBase + 0x38,    /* b RW DMA Mode                        */
  426.     DIEN            = kRegisterBase + 0x39,    /* b RW DMA Interrupt Enable            */
  427.     DWT                = kRegisterBase + 0x3A,    /* b RW DMA Watchdog Timer                */
  428.     DCNTL            = kRegisterBase + 0x3B,    /* b RW DMA Control                        */
  429.     ADDER            = kRegisterBase + 0x3C,    /* l RO Sum output of internal adder    */
  430.     SIEN0            = kRegisterBase + 0x40,    /* b RW SCSI Interrupt Enable 0            */
  431.     SIEN1            = kRegisterBase + 0x41,    /* b RW SCSI Interrupt Enable 1            */
  432.     SIST0            = kRegisterBase + 0x42,    /* b RO SCSI Interrupt Status 0            */
  433.     SIST1            = kRegisterBase + 0x43,    /* b RO SCSI Interrupt Status 1            */
  434.     SLPAR            = kRegisterBase + 0x44,    /* b RW SCSI Longitudinal Parity        */
  435.     SWIDE            = kRegisterBase + 0x45,    /* b RO SCSI Wide Residual Data            */
  436.     MACNTL            = kRegisterBase + 0x46,    /* b RW Memory Access Control            */
  437.     GPCNTL            = kRegisterBase + 0x47,    /* b RW General Purpose Control            */
  438.     STIME0            = kRegisterBase + 0x48,    /* b RW SCSI Timer 0                    */
  439.     STIME1            = kRegisterBase + 0x49,    /* b RW SCSI Timer 1                    */
  440.     RESPID0            = kRegisterBase + 0x4A,    /* b RW Response ID 0                    */
  441.     RESPID1            = kRegisterBase + 0x4B,    /* b RW Response ID 1                    */
  442.     STEST0            = kRegisterBase + 0x4C,    /* b RO SCSI Test 0                        */
  443.     STEST1            = kRegisterBase + 0x4D,    /* b RO SCSI Test 1                        */
  444.     STEST2            = kRegisterBase + 0x4E,    /* b RW SCSI Test 2                        */
  445.     STEST3            = kRegisterBase + 0x4F,    /* b RW SCSI Test 3                        */
  446.     SIDL            = kRegisterBase + 0x50,    /* w RO SCSI Input Data Latch            */
  447.     Reserved0        = kRegisterBase + 0x52,    /* w Reserved                            */
  448.     SODL            = kRegisterBase + 0x54,    /* w RW SCSI Output Data Latch            */
  449.     Reserved1        = kRegisterBase + 0x56,    /* w Reserved                            */
  450.     SBDL            = kRegisterBase + 0x58,    /* w RO SCSI Bus Data Lines                */
  451.     Reserved2        = kRegisterBase + 0x5A,    /* w Reserved                            */
  452.     SCRATCHB        = kRegisterBase + 0x5C,    /* l RW General Purpose Scratch B        */
  453.     kIORegisterMax    = kRegisterBase + 0x60    /* Off the end of the registers            */
  454. };
  455.  
  456. /*
  457.  * NCR chip access functions
  458.  */
  459. typedef enum {
  460.         kNCRResetChipInitialize        = 0,    /* Called on driver initialize            */
  461.         kNCRResetChipTerminate,                /* Called on driver termination            */
  462.         kNCRResetChipPowerDown,                /* Handle PBControl driverPowerLow        */
  463.         kNCRResetChipPowerUp,                /* Handle PBControl driverPowerHigh        */
  464.         kNCRStopCurrentScript,                /* Handle KillIO request                */
  465.         kNCRLastCommandID                    /* Enum trailing comma blocker            */
  466. } NCRChipResetCommand;
  467.  
  468.  
  469. #endif /* If not REZ */
  470. #endif /* __NCR53C825__ */